
//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File

// --- 环形缓冲器定义 ---
Uint16 rx_buffer[RX_BUFFER_SIZE]={0}; // 环形缓冲器数组
volatile Uint16 rx_buffer_write_idx = 0; // 写入索引
volatile Uint16 rx_buffer_read_idx = 0;  // 读取索引
volatile Uint16 rx_buffer_count = 0;     // 缓冲器中当前的数据量
// --- 环形缓冲器定义结束 ---

void main(void)
{
    InitSysCtrl();
    InitSciaGpio();
    DINT;
    InitPieCtrl();
    IER = 0x0000;
    IFR = 0x0000;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP1 | PIEACK_GROUP2 | PIEACK_GROUP3 |
                             PIEACK_GROUP4 | PIEACK_GROUP5 | PIEACK_GROUP6 |
                             PIEACK_GROUP7 | PIEACK_GROUP8 | PIEACK_GROUP9 |
                             PIEACK_GROUP10 | PIEACK_GROUP11 | PIEACK_GROUP12;
    InitPieVectTable();

    EALLOW;         // This is needed to write to EALLOW protected registers
    PieVectTable.SCIRXINTA = &sciaRxBasicIsr;
 //   PieVectTable.SCITXINTA = &sciaTxFifoIsr;
    EDIS;   // This is needed to disable write to EALLOW protected registers

    SciaBasicRxIntInit(115200);
//    SciaFifoInit(9600);
//    scia_fifo_init();	                // Initialize the SCI FIFO
//    scia_echoback_init();               // Initialize SCI for echoback


    PieCtrlRegs.PIECTRL.bit.ENPIE = 1;   // Enable the PIE block
    PieCtrlRegs.PIEIER9.bit.INTx1=1;     // PIE Group 9, INT1
//    PieCtrlRegs.PIEIER9.bit.INTx2=1;     // PIE Group 9, INT2
    IER = 0x100;                         // Enable CPU INT
    EINT;
//    msg = "Hello World!\0";
//    scia_msg(msg,13);
//    InitFlash();//此函数只能在RAM之外执行
    {
        APP_Updata();
    }
}
void error(void)
{
    __asm("     ESTOP0");           // Test failed!! Stop!
    for (;;);
}
//
// scia_echoback_init - Test 1,SCIA  DLB, 8-bit word, baud rate 0x000F, 
// default, 1 STOP bit, no parity
//
void scia_echoback_init(Uint32 SCIBaud)
{

 	SciaRegs.SCICCR.all =0x0007;   

	SciaRegs.SCICTL1.all =0x0003;  
    
	SciaRegs.SCICTL2.bit.TXINTENA =1;
	SciaRegs.SCICTL2.bit.RXBKINTENA =1;

	SCIBaud = 15000000 / (8 * SCIBaud) - 1;
    SciaRegs.SCIHBAUD = (SCIBaud >> 8) & 0x00ff;
    SciaRegs.SCILBAUD = SCIBaud & 0x00ff;

	SciaRegs.SCICTL1.all =0x0023;  // Relinquish SCI from Reset
}

//
// scia_xmit - Transmit a character from the SCI
//
void scia_xmit(int a)
{
    while(SciaRegs.SCICTL2.bit.TXRDY == 0) {} // 等待发送缓冲器就绪
    SciaRegs.SCITXBUF = a;
}

//
// scia_msg - 
//
void scia_msg(char * msg, Uint32 len)
{
    int i;
    i = 0;
   // TX_EN;
    while (len != 0)
    {
        scia_xmit(msg[i]);
       i++;
       len--;
    }
   // RX_EN;
}

//
// scia_fifo_init - Initialize the SCI FIFO
//
void scia_fifo_init()
{
    SciaRegs.SCIFFTX.all=0xE040;
    SciaRegs.SCIFFRX.all=0x2044;
    SciaRegs.SCIFFCT.all=0x0;
}


void SciaFifoInit(Uint32 SCIBaud)
{
    //
    // 1 stop bit,  No loopback, No parity, 8 char bits, async mode,
    // idle-line protocol
    //
    Uint32 baudRate;
    SciaRegs.SCICCR.all =0x0007;

    //
    // enable TX, RX, internal SCICLK, Disable RX ERR, SLEEP, TXWAKE
    //
    SciaRegs.SCICTL1.all =0x0003;
    SciaRegs.SCICTL2.bit.TXINTENA =1;
    SciaRegs.SCICTL2.bit.RXBKINTENA =1;

    baudRate = (Uint32)(15000000UL / (8UL * SCIBaud)) - 1UL;
    SciaRegs.SCIHBAUD = (Uint16)((baudRate >> 8) & 0x00ff);
    SciaRegs.SCILBAUD = (Uint16)(baudRate & 0x00ff);

//    SciaRegs.SCIFFTX.all=0xC022;
    SciaRegs.SCIFFRX.all=0x0021;
    SciaRegs.SCIFFCT.all=0x00;

    SciaRegs.SCICTL1.all =0x0023;     // Relinquish SCI from Reset
//    SciaRegs.SCIFFTX.bit.TXFIFOXRESET=1;
    SciaRegs.SCIFFRX.bit.RXFIFORESET=1;
}

__interrupt void sciaRxFifoIsr(void)
{
    // 从接收 FIFO 读取所有可用数据并存入环形缓冲器
    // 检查环形缓冲器是否已满，防止溢出
    while(SciaRegs.SCIFFRX.bit.RXFFST > 0) // 循环读取 FIFO 直到为空
    {
        // 检查环形缓冲器是否已满，防止溢出
        if (rx_buffer_count < RX_BUFFER_SIZE)
        {
            rx_buffer[rx_buffer_write_idx] = SciaRegs.SCIRXBUF.all; // 读取数据到环形缓冲器
            rx_buffer_write_idx = (rx_buffer_write_idx + 1) % RX_BUFFER_SIZE; // 更新写入索引（环绕）
            rx_buffer_count++; // 增加缓冲器中数据量计数
        }
        else
        {
            // 环形缓冲器溢出处理：通常这里会发出警告或丢弃数据
            // 为简单起见，这里直接丢弃字符（从 FIFO 读取以清空）
            volatile Uint16 dummyRead = SciaRegs.SCIRXBUF.all;
            // 可以在这里设置一个错误标志或计数器，指示溢出
        }
    }
    SciaRegs.SCIFFRX.bit.RXFFOVRCLR=1;   // Clear Overflow flag
    SciaRegs.SCIFFRX.bit.RXFFINTCLR=1;   // Clear Interrupt flag

    PieCtrlRegs.PIEACK.all|=0x100;       // Issue PIE ack
}
// SCI-A 基本接收中断服务程序 (非 FIFO 模式)
__interrupt void sciaRxBasicIsr(void)
{
    // 从 SCI 接收缓冲器读取接收到的字符
    // 在非 FIFO 模式下，每次中断只读取一个字节。
    // 读取 SCIRXBUF 会自动清除硬件的接收就绪标志。
    Uint16 receivedChar = SciaRegs.SCIRXBUF.all;

    // 将接收到的字符存储到环形缓冲器中
    if (rx_buffer_count < RX_BUFFER_SIZE)
    {
        rx_buffer[rx_buffer_write_idx] = receivedChar;
        rx_buffer_write_idx = (rx_buffer_write_idx + 1) % RX_BUFFER_SIZE; // 更新写入索引（环绕）
        rx_buffer_count++; // 增加缓冲器中数据量计数
    }
    else
    {
        // 环形缓冲器溢出处理：在非 FIFO 模式下，CPU 响应延迟可能导致更快溢出。
        // 可以在这里设置一个错误标志或计数器，指示溢出。
        // 无需 dummyRead，因为数据已从硬件寄存器读取。
    }

    // 在非 FIFO 模式下，没有 SCIFFRX.bit.RXFFOVRCLR 或 SCIFFRX.bit.RXFFINTCLR 需要清除。
    // 接收就绪标志由读取 SCIRXBUF 自动清除。

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP9; // 确认 PIE Group 9 中断
}
// SCI-A 模块基本接收中断初始化函数 (无 FIFO)
void SciaBasicRxIntInit(Uint32 SCIBaud)
{
    Uint32 baudRate;
    SciaRegs.SCICCR.all =0x0007;
    // 显式禁用 SCI FIFO 增强功能
    SciaRegs.SCIFFTX.bit.SCIFFENA = 0;
    //
    // enable TX, RX, internal SCICLK, Disable RX ERR, SLEEP, TXWAKE
    //
    SciaRegs.SCICTL1.all =0x0003;
    SciaRegs.SCICTL2.bit.TXINTENA = 1;
    SciaRegs.SCICTL2.bit.RXBKINTENA = 1;

    baudRate = (Uint32)(15000000UL / (8UL * SCIBaud)) - 1UL;
    SciaRegs.SCIHBAUD = (Uint16)((baudRate >> 8) & 0x00ff);
    SciaRegs.SCILBAUD = (Uint16)(baudRate & 0x00ff);

    SciaRegs.SCICTL1.all = 0x0023; // SCICTL1.bit.SWRESET = 1
}
//
// End of File
//

